home *** CD-ROM | disk | FTP | other *** search
/ Aminet 4 / Aminet 4 - November 1994.iso / aminet / comm / net / dnet2_10_13.lha / DNet / Amiga / Sourcen.lha / server / scopy.c < prev    next >
C/C++ Source or Header  |  1993-01-14  |  4KB  |  219 lines
  1.  
  2. /*
  3.  *  SCOPY.C    V1.1
  4.  *
  5.  *  DNET (c)Copyright 1988, Matthew Dillon, All Rights Reserved.
  6.  *
  7.  *  COPY SERVER FOR PUTFILES (DOWNLOADS, i.e. receives files)
  8.  *
  9.  *  The current version only accepts one connection at a time.    This server
  10.  *  handles downloading of data.  This server will eventually be replaced
  11.  *  by the SGCOPY server.  Currently the SGCOPY server only handles
  12.  *  uploads.
  13.  *
  14.  *  NOTE:   The DNET_WRITE enviroment variable must be 9 or higher or this
  15.  *        server will refuse connections.
  16.  *
  17.  *  Receive:
  18.  *        'V' NLEN NAME FILELEN       -receive compressed file    (V1.1)
  19.  *        'W' NLEN NAME FILELEN       -receive file
  20.  *        'X' NLEN NAME   0           -create and CD into directory
  21.  *        'Y'  0          0           -restore previous directory
  22.  *        'C' NLEN NAME   0           -set destination directory
  23.  *
  24.  *  length in 68000 longword format.
  25.  */
  26.  
  27. #include "defs.h"
  28.  
  29. char Buf[8192];
  30. char Buf2[8192];
  31.  
  32. int putdir ARGS((void *, char *));
  33. int putfile ARGS((void *, char *, int));
  34.  
  35. int
  36. brk()
  37. {
  38.     return(0);
  39. }
  40.  
  41. void
  42. #ifdef LATTICE
  43. _main(str)
  44. #else
  45. _main(len,str)
  46. #endif
  47. char *str;
  48. {
  49.     struct MsgPort *port;
  50.     PROC    *myproc = (PROC *)FindTask(NULL);
  51.     void    *chan;
  52.     long    savedir;
  53.     long    mask, rmask;
  54.  
  55.     onbreak(brk);
  56.  
  57.     if (strncmp(str, "__dnet", 6) != 0) {
  58.     Version("SCopy", VERSION, SCOPY_VERSION);
  59.     _exit(0);
  60.     }
  61.  
  62.     port = DListen(PORT_FILECOPY);
  63.     {
  64.     struct Message *msg;
  65.     char *dir;
  66.  
  67.     WaitPort(&myproc->pr_MsgPort);
  68.     msg = GetMsg(&myproc->pr_MsgPort);
  69.     dir = (msg->mn_Node.ln_Name) ? msg->mn_Node.ln_Name : "";
  70.     savedir = Lock(dir, SHARED_LOCK);   /* duplicate current dir    */
  71.     ReplyMsg(msg);
  72.     }
  73.     if (!savedir) {
  74.     DUnListen(port);
  75.     _exit(1);
  76.     }
  77.     savedir = CurrentDir(savedir);              /* CD dup, returns original */
  78.     mask = SIGBREAKF_CTRL_C|(1 << port->mp_SigBit);
  79.     for (;;) {
  80.     long dupdir = DupLock(myproc->pr_CurrentDir);
  81.     rmask = Wait(mask);
  82.     if (rmask & SIGBREAKF_CTRL_C) {
  83.         UnLock(CurrentDir(dupdir));
  84.         break;
  85.     }
  86.     while (chan = DAccept(port)) {
  87.         if (GetEnvVal(DNET_WRITE) >= 9)
  88.         putdir(chan, "");
  89.         else
  90.         DWrite(chan, "S", 1);
  91.         DClose(chan);
  92.     }
  93.     UnLock(CurrentDir(dupdir));
  94.     }
  95.     UnLock(CurrentDir(savedir));                /* restore original         */
  96.     DUnListen(port);
  97. }
  98.  
  99. static char Name[128];
  100.  
  101. int
  102. putdir(chan, dirname)
  103. void *chan;
  104. char *dirname;
  105. {
  106.     FIB *fib;
  107.     long lock;
  108.     long oldlock;
  109.     long len;
  110.     int ret = -1;
  111.     unsigned char co, nl, rc;
  112.  
  113.     fib = (FIB *)AllocMem(sizeof(FIB), MEMF_PUBLIC);
  114.     if ((lock = Lock(dirname, SHARED_LOCK)) == NULL) {
  115.     if (lock = CreateDir(dirname)) {
  116.         UnLock(lock);
  117.         lock = Lock(dirname, SHARED_LOCK);
  118.     }
  119.     }
  120.     if (lock == NULL || !Examine(lock,fib) || fib->fib_DirEntryType < 0) {
  121.     if (lock)
  122.         UnLock(lock);
  123.     rc = 'N';
  124.     DWrite(chan, &rc, 1);
  125.     FreeMem(fib, sizeof(FIB));
  126.     return(1);
  127.     }
  128.     rc = 'Y';
  129.     DWrite(chan, &rc, 1);
  130.     oldlock = CurrentDir(lock);
  131.     while (DRead(chan, &co, 1) == 1) {
  132.     if (DRead(chan, &nl, 1) != 1 || DRead(chan, Name, nl) != nl)
  133.         break;
  134.     if (DRead(chan, &len, 4) != 4)
  135.         break;
  136.     switch(co) {
  137.     case 'C':
  138.         {
  139.         char co = 'N';
  140.         long lock = Lock(Name, SHARED_LOCK);    /* CD to dir */
  141.         if (!lock) {
  142.             if (lock = CreateDir(Name)) {       /* or create */
  143.             UnLock(lock);
  144.             lock = Lock(Name, SHARED_LOCK);
  145.             }
  146.         }
  147.         if (lock) {
  148.             co = 'Y';
  149.             UnLock(CurrentDir(lock));
  150.         }
  151.         DWrite(chan, &co, 1);
  152.         }
  153.         break;
  154.     case 'W':
  155.         if (putfile(chan, Name, len) < 0) {
  156.         ret = -1;
  157.         goto fail;
  158.         }
  159.         break;
  160.     case 'X':
  161.         if (putdir(chan, Name) < 0) {
  162.         ret = -1;
  163.         goto fail;
  164.         }
  165.         break;
  166.     case 'Y':
  167.         ret = 1;
  168.         co = 'Y';
  169.         DWrite(chan, &co, 1);
  170.         goto fail;
  171.     default:
  172.         co = 'N';
  173.         DWrite(chan, &co, 1);
  174.         break;
  175.     }
  176.     }
  177. fail:
  178.     UnLock(CurrentDir(oldlock));
  179.     FreeMem(fib, sizeof(FIB));
  180.     return(ret);
  181. }
  182.  
  183. int
  184. putfile(chan, name, len)
  185. void *chan;
  186. char *name;
  187. int len;
  188. {
  189.     long fh = Open(name, 1006);
  190.     long n, r;
  191.     char rc;
  192.  
  193.     if (fh == NULL) {
  194.     rc = 'N';
  195.     DWrite(chan, &rc, 1);
  196.     return(0);
  197.     }
  198.     rc = 'Y';
  199.     DWrite(chan, &rc, 1);
  200.     while (len) {
  201.     r = (len > sizeof(Buf)) ? sizeof(Buf) : len;
  202.     n = DRead(chan, Buf, r);
  203.     if (n != r)
  204.         break;
  205.     if (Write(fh, Buf, n) != n)
  206.         break;
  207.     len -= n;
  208.     }
  209.     Close(fh);
  210.     if (len) {
  211.     unlink(name);
  212.     return(-1);
  213.     }
  214.     rc = 'Y';
  215.     DWrite(chan, &rc, 1);
  216.     return(0);
  217. }
  218.  
  219.